home *** CD-ROM | disk | FTP | other *** search
/ NeXT Education Software Sampler 1992 Fall / NeXT Education Software Sampler 1992 Fall.iso / Programming / Classes / SocketClasses / SktSocketManager.m < prev    next >
Encoding:
Text File  |  1992-07-23  |  37.0 KB  |  914 lines
  1. /***************************************************************************
  2. *                                                                          *
  3. * SktSocketManager.m                                                       *
  4. * Copyright 1992 by Nik A Gervae                                           *
  5. *                                                                          *
  6. * One of a set of three Objective-C classes (SktSocketManager, SktSocket,  *
  7. * and SktSocketUser) which implement a convenient interface to Berkeley    *
  8. * stream sockets under NeXTSTEP(r).  See the accompanying class            *
  9. * specifications (files with a .rtf or .spec suffix) for further           *
  10. * information.                                                             *
  11. *                                                                          *
  12. * NeXTSTEP is a registered trademark of NeXT Computer, Inc.                *
  13. *                                                                          *
  14. ****************************************************************************
  15. *                                                                          *
  16. * LICENSE                                                                  *
  17. *                                                                          *
  18. * This program is free software; you can redistribute it and/or modify     *
  19. * it under the terms of the GNU General Public License as published by     *
  20. * the Free Software Foundation.                                            *
  21. *                                                                          *
  22. * The program and this makefile are distributed in the hope that it will   *
  23. * be useful, but are provided "AS IS" AND WITHOUT ANY WARRANTY; without    *
  24. * any express or implied warranty of MERCHANTABILITY or FITNESS FOR A      *
  25. * PARTICULAR PURPOSE. See the GNU General Public License for more details. *
  26. * Any use or distribution of the program and documentation must include    *
  27. * appropriate copyrights to acknowledge Nik A. Gervae and the Free         *
  28. * Software Foundation, Inc.                                                *
  29. * You should have received a copy of the GNU General Public License        *
  30. * along with this program; if not, write to the Free Software              *
  31. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                *
  32. *                                                                          *
  33. ****************************************************************************
  34. *                                                                          *
  35. * VERSION HISTORY                                                          *
  36. *                                                                          *
  37. * Version numbers are simply dates in the form YYYYMMDD.  These represent  *
  38. * the date that version was finished.  Only significantly changed versions *
  39. * are reported here, or those versions requiring explanation of changes.   *
  40. * There may be many interim stages between dated versions.                 *
  41. *                                                                          *
  42. * DateVersion Primary Author  Notes                                        *
  43. * ----------- --------------- -------------------------------------------- *
  44. * 19920327    Nik A Gervae    First released version                       *
  45. * 19920723    Nik A Gervae    Actually released                            *
  46. *                                                                          *
  47. ***************************************************************************/
  48.  
  49. #import <errno.h>
  50. #import <stdio.h>
  51.  
  52. #import <sys/param.h>
  53. #import <sys/types.h>
  54. #import <sys/socket.h>
  55. #import <sys/time.h>
  56. #import <netinet/in.h>
  57. #import <netdb.h>
  58.  
  59. #import <objc/List.h>
  60.  
  61. #import "SktSocketManager.h"
  62.  
  63. extern int errno;
  64.  
  65.  
  66. /***************************************************************************
  67. *                                                                          *
  68. * These are the constant strings used.  Feel free to translate them into   *
  69. * your favorite language.  Do be sure to keep all the % directives in      *
  70. * place, or change the code that accesses these strings.                   *
  71. *                                                                          *
  72. ***************************************************************************/
  73. #define STR_Error             "ERROR (%s): "
  74.  
  75. #define STR_MallocFatalError   STR_Error "zone malloc failed.\n"
  76.  
  77. #define STR_BadCapacity       STR_Error "specified capacity (%d) invalid.\n"
  78. #define STR_NoUserClass       STR_Error "no user class specified for " \
  79.                                "initializing.\n"
  80. #define STR_NotUserClass      STR_Error "%s is not a subclass of " \
  81.                                "SktSocketUser.\n"
  82. #define STR_CantGetSocket     STR_Error "unable to get service socket.\n"
  83. #define STR_CantSetOptions    STR_Error "unable to set sender\'s options.\n"
  84. #define STR_CantBindSocket    STR_Error "unable to bind socket.\n"
  85. #define STR_CantGetSocketName STR_Error "unable to get socket name.\n"
  86. #define STR_CantCreateList    STR_Error "unable to create openSockets " \
  87.                                "list.\n"
  88.  
  89.  
  90. #define STR_NoHostInfo        "(%s) Cannot get host information.\n"
  91. #define STR_NoFds             "(%s) No more fds. Closing new connection.\n"
  92. #define STR_NoNewConnects     "No new connections can be accepted  at this " \
  93.                                "time. Sorry.\n"
  94. #define STR_ClosingSocket     "(%s) closing SktSocket with socketFd %d\n"
  95.  
  96. #define STR_SelectEBADF       "(%s) bad fd in select().\n"
  97. #define STR_SelectEINTR       "(%s) signal during select().\n"
  98. #define STR_SelectEINVAL      "(%s) invalid timeout in select().\n"
  99. #define STR_SelectErrUnknown  "(%s) unknown select() error #%d.\n"
  100. #define STR_NewSocketDied     STR_Error "coudn\'t create/init new socket.\n"
  101. #define STR_NewUserDied       STR_Error "coudn\'t create/init new user.\n"
  102. #define STR_CantCreateUserSorry "Can\'t create needed resources to accept " \
  103.                                  "a new connection.  Sorry.\n"
  104.  
  105. #define STR_Unknown           "(unknown)"
  106.  
  107.  
  108.  
  109. @implementation SktSocketManager
  110.  
  111. /***************************************************************************
  112. *                                                                          *
  113. * -init                                                                    *
  114. *                                                                          *
  115. ***************************************************************************/
  116. - init
  117. {
  118.   return [self notImplemented:_cmd];
  119. }
  120.  
  121. /***************************************************************************
  122. *                                                                          *
  123. * -initPort:logfile:fdCapacity:userClass:options:                          *
  124. *                                                                          *
  125. * THIS IS THE DESIGNATED INITIALIZER FOR THIS CLASS.                       *
  126. *                                                                          *
  127. * This method does a hell of a lot.  It has to establish all ivars, check  *
  128. * the amount of available file descriptors for sockets, check the supplied *
  129. * user class, get a socket for service connections, bind it, verify is,    *
  130. * and listen for connections. See below for the nitty-gritty.              *
  131. *                                                                          *
  132. * ERROR CONDITIONS: The following conditions cause a return of nil:        *
  133. *                                                                          *
  134. * - The specified capacity is invalid.                                     *
  135. * - The specified user class is nil or is not a subclass of SktSocketUser. *
  136. * - The socket can't be created or bound, or verified.                     *
  137. * - setSocketOptions returns nil.                                          *
  138. * - The List object of open SktSockets can't be allocated/initted.         *
  139. *                                                                          *
  140. ***************************************************************************/
  141. - initPort:(int)portNum logfile:(FILE *)file fdCapacity:(int)cap
  142.     userClass:aClass
  143. {
  144.   int  slen = sizeof(struct sockaddr_in);  // for use in inet functions
  145.   char host_name[MAXHOSTNAMELEN+1];        // for getting the hostname
  146.   struct sockaddr_in  server;              // for binding the socket
  147.   struct sockaddr_in  hostaddr_in;         // for getting the inet address
  148.   struct hostent     *host;                // for getting the inet address
  149.  
  150.   [super init];
  151.   zone = [self zone];
  152.  
  153.  /*
  154.   * Set up the logfile right away, and initialize ivars to be void
  155.   * until we can fill them in later.  Also check cap against the
  156.   * number of available fds.
  157.   */
  158.   logfile     = file;
  159.   userClass   = nil;
  160.   openSockets = nil;
  161.   hostaddress = hostname = NULL;
  162.   doesLog     = YES;
  163.  
  164.  /*
  165.   * Default select() behavior in -update is to poll (0 timeout),
  166.   * not block, and not to cover any signals.
  167.   */
  168.   selectTimeout.tv_sec  = 0;
  169.   selectTimeout.tv_usec = 0;
  170.   timeoutIndefinite     = NO;
  171.   selectSignalMask      = 0;
  172.  
  173.   if (0 > cap || getdtablesize() < cap) {
  174.     [self log:STR_BadCapacity, [self name], cap];
  175.     return [self free];
  176.   }
  177.   numAvailFds = cap;
  178.  
  179.  /*
  180.   * If aClass is not a subclass of SktSocketUser, don't init.
  181.   */
  182.   if (!aClass) {
  183.     [self log:STR_NoUserClass, [self name]];
  184.     return [self free];
  185.   }
  186.  
  187.   if (![aClass isKindOf:objc_getMetaClass([[SktSocketUser class] name])]) {
  188.     [self log:STR_NotUserClass, [self name], [aClass name]];
  189.     return [self free];
  190.   }
  191.  
  192.   userClass = [aClass class];  // Send class message just in case.
  193.  
  194.  /*
  195.   * A new socket, please.  And don't init if we can't get one.
  196.   * If the sender wanted to set some options, try to do so, but
  197.   * don't init if the provided function returns NO.
  198.   */
  199.   serviceSocketFd = socket(AF_INET, SOCK_STREAM, 0);
  200.   if (0 > serviceSocketFd) {
  201.     [self log:STR_CantGetSocket, [self name]];
  202.     return [self free];
  203.   }
  204.  
  205.   if (![self setSocketOptions:serviceSocketFd]) {
  206.     [self log:STR_CantSetOptions, [self name]];
  207.     return [self free];
  208.   }
  209.  
  210.  /*
  211.   * bind() the socket.  This part is messy, 'cause we have to get
  212.   * all sorts of random garbage info to get what we really need.
  213.   */
  214.   gethostname(host_name, sizeof(host_name));
  215.   if (NULL == (host = gethostbyname(host_name))) {
  216.     server.sin_family = AF_INET;
  217.     hostaddress = NULL;
  218.   }
  219.   else {
  220.     server.sin_family = host->h_addrtype;
  221.     memcpy((char *)&hostaddr_in.sin_addr.s_addr, (char *)host->h_addr_list[0], 
  222.           host->h_length);
  223.  
  224.    /*
  225.     * Not fatal if this fails. (May need to change this.)
  226.     */
  227.     hostaddress = zoneStrdup([self zone],
  228.                              (char *)inet_ntoa(hostaddr_in.sin_addr));
  229.  
  230.     if (!hostaddress) {
  231.       [self log:STR_MallocFatalError, [self name]];
  232.     }
  233.   }
  234.  
  235.  /*
  236.   * Not fatal if this fails.  (May need to change this.)
  237.   */
  238.   hostname = zoneStrdup([self zone], host_name);
  239.   if (!hostname) {
  240.     [self log:STR_MallocFatalError, [self name]];
  241.   }
  242.  
  243.   server.sin_addr.s_addr = htonl(INADDR_ANY);
  244.   server.sin_port        = htonl(portNum);
  245.   if (bind(serviceSocketFd, (struct sockaddr *)&server, slen)) {
  246.     [self log:STR_CantBindSocket, [self name]];
  247.     return [self free];
  248.   }
  249.  
  250.  /*
  251.   * Verify socket and listen() for connection requests.
  252.   */
  253.   if (0 > getsockname(serviceSocketFd, (struct sockaddr *)&server, &slen)) {
  254.     [self log:STR_CantGetSocketName, [self name]];
  255.     return [self free];
  256.   }
  257.   listen(serviceSocketFd, 5);
  258.  
  259.  /*
  260.   * Establish more instance variables.
  261.   */
  262.   servicePort = portNum;
  263.   maxSocketFd = serviceSocketFd;
  264.  
  265.   openSockets = [[List allocFromZone:[self zone]] initCount:5];
  266.  
  267.   if (!openSockets) {
  268.     [self log:STR_CantCreateList, [self name]];
  269.     return [self free];
  270.   }
  271.  
  272.   return self;
  273.  
  274. } /*initPort:logfile:fdCapacity:userClass:*/
  275.  
  276. /***************************************************************************
  277. *                                                                          *
  278. * -setSocketOptions                                                        *
  279. *                                                                          *
  280. * This method sets no options, as the SktSocketManager needs none set.  It *
  281. * may be overriden in subclasses to set other socket/file descriptor       *
  282. * options via setsockopt/fcntl.                                            *
  283. *                                                                          *
  284. * If this method returns nil, then any initialization is aborted and the   *
  285. * init... method will return nil.                                          *
  286. *                                                                          *
  287. ***************************************************************************/
  288. - setSocketOptions:(int)fd
  289. {
  290.   return self;
  291. }
  292.  
  293. /***************************************************************************
  294. *                                                                          *
  295. * -free                                                                    *
  296. *                                                                          *
  297. * Does the obvious.  Also kills all connections.                           *
  298. *                                                                          *
  299. ***************************************************************************/
  300. - free
  301. {
  302.   if (hostaddress) free(hostaddress);
  303.   if (hostname) free(hostname);
  304.   [self closeAllSockets];
  305.   if (openSockets) [openSockets free];
  306.   shutdown(serviceSocketFd, 2);
  307.   return [super free];
  308. }
  309.  
  310. /***************************************************************************
  311. *                                                                          *
  312. * -setDoesLog:                                                             *
  313. *                                                                          *
  314. * Allows you to change whether the user logs non-error messages (which may *
  315. * nonetheless be quite important). The default is YES.                     *
  316. *                                                                          *
  317. ***************************************************************************/
  318. - setDoesLog:(BOOL)flag
  319. {
  320.   doesLog = flag;
  321.   return self;
  322. }
  323.  
  324. /***************************************************************************
  325. *                                                                          *
  326. * -doesLog                                                                 *
  327. *                                                                          *
  328. * YES if non-error messages are logged (the default), NO if not.  Simple.  *
  329. *                                                                          *
  330. ***************************************************************************/
  331. - (BOOL)doesLog
  332. {
  333.   return doesLog;
  334. }
  335.  
  336. /***************************************************************************
  337. *                                                                          *
  338. * -setTimeoutSeconds:microseconds:                                         *
  339. *                                                                          *
  340. * Sets the timeout for checking i/o.  The SktSocketManager will not wait   *
  341. * longer than this before beginning to process an -update message.  If the *
  342. * timeout is (0,0) then -update simply polls for immediately available i/o *
  343. * operations and performs them.                                            *
  344. *                                                                          *
  345. * This method clears and deactivates timeoutIndefinite.                    *
  346. *                                                                          *
  347. ***************************************************************************/
  348. - setTimeoutSeconds:(long int)secs microseconds:(long int)usecs
  349. {
  350.   if (0 > secs || 0 > usecs) return nil;
  351.  
  352.   timeoutIndefinite     = NO;
  353.   selectTimeout.tv_sec  = secs;
  354.   selectTimeout.tv_usec = usecs;
  355.  
  356.   return self;
  357. }
  358.  
  359. /***************************************************************************
  360. *                                                                          *
  361. * -getTimeoutSeconds:microseconds:                                         *
  362. *                                                                          *
  363. * Gets the timeout for checking i/o.  The SktSocketManager will not wait   *
  364. * longer than this before beginning to process an -update message.  If the *
  365. * timeout is (0,0) then -update simply polls for immediately available i/o *
  366. * operations and performs them.                                            *
  367. *                                                                          *
  368. * This method returns NO if the timeout does not apply; that is, if        *
  369. * timeoutIndefinite is in effect.                                          *
  370. *                                                                          *
  371. ***************************************************************************/
  372. - (BOOL)getTimeoutSeconds:(long int *)secs microseconds:(long int *)usecs
  373. {
  374.   *secs  = selectTimeout.tv_sec;
  375.   *usecs = selectTimeout.tv_usec;
  376.  
  377.   return !timeoutIndefinite;
  378. }
  379.  
  380. /***************************************************************************
  381. *                                                                          *
  382. * -setTimeoutIndefinite                                                    *
  383. *                                                                          *
  384. * Causes the SktSocketManager to block indefinitely in -update until there *
  385. * is an i/o operation to perform, or a signal occurs.                      *
  386. *                                                                          *
  387. ***************************************************************************/
  388. - setTimeoutIndefinite
  389. {
  390.   timeoutIndefinite = YES;
  391.   return self;
  392. }
  393.  
  394. /***************************************************************************
  395. *                                                                          *
  396. * -isTimeoutIndefinite                                                     *
  397. *                                                                          *
  398. * Returns whether the SktSocketManager blocks indefinitely in -update      *
  399. * until there is an i/o operation to perform, or a signal occurs.          *
  400. *                                                                          *
  401. ***************************************************************************/
  402. - (BOOL)isTimeoutIndefinite
  403. {
  404.   return timeoutIndefinite;
  405. }
  406.  
  407. /***************************************************************************
  408. *                                                                          *
  409. * -setSignalMask:                                                          *
  410. *                                                                          *
  411. * Sets the signal mask used during a select(), and returns the old one.    *
  412. * Note the difference from the standard sigsetmask() system call!          *
  413. *                                                                          *
  414. ***************************************************************************/
  415. - (int)setSignalMask:(int)sigmask;
  416. {
  417.   int oldmask = selectSignalMask;
  418.   selectSignalMask = sigmask;
  419.   return oldmask;
  420. }
  421.  
  422. /***************************************************************************
  423. *                                                                          *
  424. * -signalMask                                                              *
  425. *                                                                          *
  426. * Returns the signal mask used during a select().  This is not a cover for *
  427. * the sigmask() system call!                                               *
  428. *                                                                          *
  429. ***************************************************************************/
  430. - (int)signalMask;
  431. {
  432.   return selectSignalMask;
  433. }
  434.  
  435. /***************************************************************************
  436. *                                                                          *
  437. * -setFdCapacity:                                                          *
  438. *                                                                          *
  439. * Sets the maximum amount of connections that will be allowed at one time. *
  440. * Various error checking is done.  This method can be used to reserve some *
  441. * of the process's file descriptors for other use (log/temp files).        *
  442. *                                                                          *
  443. ***************************************************************************/
  444. - setFdCapacity:(int)cap
  445. {
  446.   int assigned;
  447.  
  448.   assigned = [openSockets count];
  449.  
  450.   if (getdtablesize() < cap || assigned > cap) {
  451.     return nil;
  452.   }
  453.   else if (0 > cap) {
  454.     numAvailFds = 0;
  455.     return nil;
  456.   }
  457.   else {
  458.     numAvailFds = cap - assigned;
  459.   }
  460.   return self;
  461. }
  462.  
  463. /***************************************************************************
  464. *                                                                          *
  465. * -adjustFdCapacity:                                                       *
  466. *                                                                          *
  467. * Adjusts the maximum amount of connections that will be allowed at one    *
  468. * time.  Various error checking is done.  This method can be used to       *
  469. *  reserve some of the process's file descriptors for other use (log/temp  *
  470. * files).                                                                  *
  471. *                                                                          *
  472. ***************************************************************************/
  473. - (int)adjustFdCapacity:(int)byAmount
  474. {
  475.   int newAvailFds;
  476.   int assigned;
  477.  
  478.   newAvailFds = numAvailFds + byAmount;
  479.   assigned = [openSockets count];
  480.  
  481.   if (getdtablesize() < newAvailFds + assigned) {
  482.  
  483.     return -1;
  484.  
  485.   } else if (0 > newAvailFds) {
  486.  
  487.     numAvailFds = 0;
  488.     return -1;
  489.  
  490.   }
  491.   else {
  492.     numAvailFds = newAvailFds;
  493.   }
  494.   return numAvailFds + assigned;
  495. }
  496.  
  497. /***************************************************************************
  498. *                                                                          *
  499. * -fdCapacity                                                              *
  500. *                                                                          *
  501. * Returns the maximum amount of connections that will be allowed at one    *
  502. * time.                                                                    *
  503. *                                                                          *
  504. ***************************************************************************/
  505. - (int)fdCapacity
  506. {
  507.   return numAvailFds + [openSockets count];
  508. }
  509.  
  510. /***************************************************************************
  511. *                                                                          *
  512. * -numAvailFds                                                             *
  513. *                                                                          *
  514. * Returns the amount of file desctiptors free for further connections.     *
  515. *                                                                          *
  516. ***************************************************************************/
  517. - (int)numAvailFds
  518. {
  519.   return numAvailFds;
  520. }
  521.  
  522. /***************************************************************************
  523. *                                                                          *
  524. * -logfile                                                                 *
  525. *                                                                          *
  526. * Return the FILE pointer for the file all log messages are written to.    *
  527. *                                                                          *
  528. ***************************************************************************/
  529. - (FILE *)logfile
  530. {
  531.   return logfile;
  532. }
  533.  
  534. /***************************************************************************
  535. *                                                                          *
  536. * -hostaddress                                                             *
  537. *                                                                          *
  538. * Returns the address of the host the SktSocketManager's process is        *
  539. * on, in dot notation.                                                     *
  540. *                                                                          *
  541. ***************************************************************************/
  542. - (const char *)hostaddress
  543. {
  544.   if (hostaddress) return (const char *)hostaddress;
  545.   else return STR_Unknown;
  546. }
  547.  
  548. /***************************************************************************
  549. *                                                                          *
  550. * -hostname                                                                *
  551. *                                                                          *
  552. * Returns the name of the host the SktSocketManager's process is on.       *
  553. *                                                                          *
  554. ***************************************************************************/
  555. - (const char *)hostname
  556. {
  557.   if (hostname) return (const char *)hostname;
  558.   else return STR_Unknown;
  559. }
  560.  
  561. /***************************************************************************
  562. *                                                                          *
  563. * -servicePort                                                             *
  564. *                                                                          *
  565. * The Internet port number used to connect to the SktSocketManager.        *
  566. *                                                                          *
  567. ***************************************************************************/
  568. - (int)servicePort
  569. {
  570.   return servicePort;
  571. } 
  572.  
  573. /***************************************************************************
  574. *                                                                          *
  575. * -getInetAddresses                                                        *
  576. *                                                                          *
  577. * Return a NULL-terminated array of character strings representing all of  *
  578. * the Internet addresses of the host machine. The sender may free the      *
  579. * array returned when it is no longer needed (just free the top-level      *
  580. * pointer).                                                                *
  581. *                                                                          *
  582. * The array is allocated in the default malloc zone.                       *
  583. *                                                                          *
  584. * ERROR CONDITION: If the allocation of the array fails, a message is      *
  585. * logged, and NULL is returned.                                            *
  586. *                                                                          *
  587. ***************************************************************************/
  588. - (char **)getInetAddresses
  589. {
  590.   struct hostent     *host;          // the record for the host
  591.   struct sockaddr_in  thisHostaddr;  // 
  592.   int                 count, this;
  593.   int                 totalSize;
  594.   char              **addresses; // Used to return inet addresses
  595.   char               *loc;
  596.  
  597.  /*
  598.   * Get the host's name and count the number of addresses it has.
  599.   */
  600.   if (NULL == (host = gethostbyname(hostname))) {
  601.     [self log:STR_NoHostInfo, [self name]];
  602.     return NULL;
  603.   }
  604.   for (count = 0; host->h_addr_list[count] != NULL; count++)
  605.     ;
  606.  
  607.  /*
  608.   * Count up the total amount we need to malloc to get all the
  609.   * strings and their pointers.
  610.   */
  611.   totalSize = (1+count) * sizeof(char *);
  612.  
  613.   for (this = 0; this < count && NULL != host->h_addr_list[this]; this++) {
  614.     memcpy((char *)&(thisHostaddr.sin_addr.s_addr),
  615.            (char *)host->h_addr_list[this],
  616.            host->h_length);
  617.  
  618.     totalSize += 1 + strlen(inet_ntoa(thisHostaddr.sin_addr));
  619.   }
  620.   addresses = (char **)NXZoneMalloc(NXDefaultMallocZone(), totalSize);
  621.   if (!addresses) {
  622.     [self log:STR_MallocFatalError, [self name]];
  623.     return NULL;
  624.   }
  625.  
  626.  /*
  627.   * Now copy each address into the proper offset in the array, and
  628.   * set a pointer to it at the beginning.
  629.   */
  630.   loc = (char *)(addresses + count + 1);
  631.   for (this = 0; this < count && NULL != host->h_addr_list[this]; this++) {
  632.  
  633.     char     *dummy;
  634.     long int  size;
  635.  
  636.     memcpy((char *)&(thisHostaddr.sin_addr.s_addr),
  637.            (char *)host->h_addr_list[this],
  638.            host->h_length);
  639.     dummy = (char *)inet_ntoa(thisHostaddr.sin_addr);
  640.     size = 1+strlen(dummy);
  641.  
  642.     *(addresses + this) = loc;
  643.     memcpy(loc, dummy, size);
  644.     loc += size;
  645.   }
  646.  
  647.  /*
  648.   * Remember, it's a NULL-terminated array of arrays.
  649.   */
  650.   addresses[this] = NULL;
  651.  
  652.   return addresses;
  653.  
  654. } /*getInetAddresses*/
  655.  
  656. /***************************************************************************
  657. *                                                                          *
  658. * -update                                                                  *
  659. *                                                                          *
  660. * In brief (see below for details):                                        *
  661. *  - Do asynchronous input via select(). This is the messy part.           *
  662. *  - Drop any sockets with exceptions pending.                             *
  663. *  - Have individual sockets flush output.                                 *
  664. *  - Have them queue input.                                                *
  665. *  - Check for new connections. (Always do this last.)                     *
  666. *                                                                          *
  667. * ERROR CONDITION: If a new SktSocket/User pair need to be created, and    *
  668. * either can't be, this method logs a message and returns immediately.     *
  669. * This is not a fatal error.                                               *
  670. *                                                                          *
  671. ***************************************************************************/
  672. - update
  673. {
  674.   int             i;                // general loop variable
  675.   id              currentSocket;    // use in loops
  676.   int             currentSocketFd;  // use in loops
  677.  
  678.   int             oldmask;          // used to protect select() from signals
  679.   int             numpending;       // result of select()
  680.   fd_set          readfds;          // for select()
  681.   fd_set          exceptfds;        // for select()
  682.   struct timeval *timeout;          // for select()
  683.  
  684.  /*
  685.   * Prepare for select().  Set the timeout, the fd sets, and
  686.   * mask any signals requested.
  687.   */
  688.   if (timeoutIndefinite) timeout = NULL;
  689.   else timeout = &selectTimeout;
  690.  
  691.   FD_ZERO(&readfds);
  692.   FD_ZERO(&exceptfds);
  693.  
  694.   FD_SET(serviceSocketFd, &readfds);
  695.   for (i = [openSockets count]-1; 0 <= i; i--) {
  696.     currentSocketFd = [[openSockets objectAt:i] socketFd];
  697.     FD_SET(currentSocketFd, &readfds);
  698.     FD_SET(currentSocketFd, &exceptfds);
  699.   }
  700.  
  701.   oldmask = sigsetmask(selectSignalMask);
  702.  
  703.   numpending = select(maxSocketFd+1,
  704.                       &readfds,
  705.                       (fd_set *)0,  // SktSockets handle write()s
  706.                       &exceptfds,
  707.                       timeout);
  708.   sigsetmask(oldmask);
  709.  
  710.  /*
  711.   * Error occured: report and don't do anything this time
  712.   * (odds are it was a signal).
  713.   */
  714.   if (0 > numpending) {
  715.     if (doesLog) switch (errno) {
  716.       case EBADF:
  717.         [self log:STR_SelectEBADF, [self name]];
  718.         break;
  719.       case EINTR:
  720.         [self log:STR_SelectEINTR, [self name]];
  721.         break;
  722.       case EINVAL:
  723.         [self log:STR_SelectEINVAL, [self name]];
  724.         break;
  725.       default:
  726.         [self log:STR_SelectErrUnknown, [self name], errno];
  727.         break;
  728.     }
  729.     return self;
  730.   }
  731.  
  732.  /*
  733.   * Drop sockets with exception conditions (assume corrupt connection).
  734.   * It is the socket user's responsibility to notice that its SktSocket
  735.   * is gone, and to clean up appropriately.
  736.  
  737.   * Have to go backwards 'cause List slides contents forward on removal.
  738.   */
  739.   for (i = [openSockets count]-1; 0 <= i; i--) {
  740.  
  741.     currentSocket = [openSockets objectAt:i];
  742.     currentSocketFd = (int)[currentSocket socketFd];
  743.  
  744.     if (FD_ISSET(currentSocketFd, &exceptfds)) {
  745.       FD_CLR(currentSocketFd, &readfds);
  746.       [self closeSocket:currentSocket];
  747.     }
  748.  
  749.   }
  750.  
  751.  /*
  752.   * Have all sockets flush output. We don't need writefds for this.
  753.   */
  754.   [openSockets makeObjectsPerform:@selector(flushOutput)];
  755.  
  756.  /*
  757.   * Have each socket read one block of input. Use the info from
  758.   * select() in this messy loop to avoid the hassle and overhead
  759.   * of nonblocking read()'s where they might be unnecessary.
  760.   * If readInput returns nil, the socket connection is closed/dead
  761.   * (EOF), and the SktSocket should be closed.  It is the socket
  762.   * user's responsibility to notice that its SktSocket is gone,
  763.   * and to clean up appropriately.
  764.   */
  765.   for (i = [openSockets count]-1; 0 <= i; i--) {
  766.  
  767.     currentSocket   = [openSockets objectAt:i];
  768.     currentSocketFd = [currentSocket socketFd];
  769.  
  770.     if (FD_ISSET(currentSocketFd, &readfds)) {      
  771.       if (![currentSocket readInput]) {
  772.         [self closeSocket:currentSocket];
  773.       }
  774.     }
  775.   }
  776.  
  777.  /* 
  778.   * Accept new connections if possible.
  779.   */
  780.   if (FD_ISSET(serviceSocketFd, &readfds)) {
  781.  
  782.     id  newSocket;
  783.     int newSocketFd;
  784.     id  newUser;
  785.  
  786.    /*
  787.     * Create a new SktSocket and a user.  Log messages if they
  788.     * can't be created, and return.
  789.     */
  790.     newSocket = [[SktSocket allocFromZone:zone] initOnFd:serviceSocketFd
  791.                  withManager:self];
  792.     if (!newSocket) {
  793.       [self log:STR_NewSocketDied, [self name]];
  794.       return self;
  795.     }
  796.  
  797.     newSocketFd = [newSocket socketFd];
  798.  
  799.     newUser = [[userClass allocFromZone:zone] initWithSocket:newSocket];
  800.     if (!newUser) {
  801.       [self log:STR_NewUserDied, [self name]];
  802.       [newSocket queueOutputString:STR_CantCreateUserSorry];
  803.       [newSocket flushOutput];
  804.       [newSocket free];
  805.       return self;
  806.     }
  807.  
  808.    /*
  809.     * Check that we have room for it and update bookkeeping info.
  810.     */
  811.     if ([openSockets count] < numAvailFds) {
  812.       if (newSocketFd > maxSocketFd) maxSocketFd = newSocketFd;
  813.       [openSockets addObject:newSocket];
  814.     }
  815.     else {
  816.       [self log:STR_NoFds, [self name]];
  817.       [newSocket queueOutputString:STR_NoNewConnects];
  818.       [newSocket flushOutput];
  819.  
  820.       [newSocket free];
  821.       [newUser free];
  822.     } 
  823.  
  824.   } /*if (FD_ISSET())*/
  825.  
  826.   return self;
  827.  
  828. } /*update*/
  829.  
  830. /***************************************************************************
  831. *                                                                          *
  832. * -closeSocket:                                                            *
  833. *                                                                          *
  834. * Remove a socket from the list of currently open sockets, have the        *
  835. * SktSocket object clean itself up and die, and update bookeeping info.    *
  836. * Do NOT kill the socket user here!  It has to find out its socket is gone *
  837. * and take appropriate action.                                             *
  838. *                                                                          *
  839. ***************************************************************************/
  840. - closeSocket:socketObj
  841. {
  842.   [self log:STR_ClosingSocket, [self name], [socketObj socketFd]];
  843.  
  844.   [openSockets removeObject:socketObj];
  845.   if ([socketObj socketFd] == maxSocketFd) {
  846.     maxSocketFd--;
  847.   }
  848.  
  849.   [socketObj free];
  850.  
  851.   return self;
  852.  
  853. }
  854.  
  855. /***************************************************************************
  856. *                                                                          *
  857. * closeAllSockets                                                          *
  858. *                                                                          *
  859. * Have all SktSocket objects clean up and die.                             *
  860. *                                                                          *
  861. ***************************************************************************/
  862. - closeAllSockets
  863. {
  864.   int i;
  865.  
  866.   for (i = [openSockets count] - 1; 0 <= i; i--) {
  867.     [self closeSocket:[openSockets objectAt:i]];
  868.   }
  869.   return self;
  870.  
  871. }
  872.  
  873. /***************************************************************************
  874. *                                                                          *
  875. * -announceString:                                                         *
  876. *                                                                          *
  877. * Dump the given string on each socket.                                    *
  878. *                                                                          *
  879. ***************************************************************************/
  880. - announceString:(const char *)announcement
  881. {
  882.   int numfds;
  883.   int i;
  884.  
  885.   numfds = [openSockets count];
  886.   for (i = 0; i < numfds; i++) {
  887.     [[openSockets objectAt:i] queueOutputString:announcement];
  888.   }
  889.  
  890.   return self;
  891. }
  892.  
  893. /***************************************************************************
  894. *                                                                          *
  895. * -log:                                                                    *
  896. *                                                                          *
  897. * Print a message to the logfile.  You can use this exactly like printf,   *
  898. * 'cause that's what it uses.                                              *
  899. *                                                                          *
  900. ***************************************************************************/
  901. - log:(const char *)format, ...
  902. {
  903.   va_list  param_list;
  904.  
  905.   va_start(param_list, format);
  906.   vfprintf(logfile, format, param_list);
  907.   fflush(logfile);
  908.   va_end(param_list);
  909.   return self;
  910.  
  911. }
  912.  
  913. @end /*implementation SktSocketManager*/
  914.